In our British Patent No. 2281682, there is described a 3-D rendering system for polygons in which each object is seen to be viewed as defined in a set of surfaces which are infinite. Each elementary area of the screen in which an image is to be displayed has a ray projected through it from a viewpoint into the 3-dimensional scene. The location of the intersection of the projected ray with each surface is then determined. From these intersections, it is then possible to determine whether any intersected surface is visible at that elementary area. The elementary area is then shaded for display in dependence on the results of the determination.
The system can be implemented in a pipeline type processor comprising a number of cells, each of which can perform an intersection calculation with a surface. Thus, a large number of surface intersections can be computed simultaneously. Each cell is loaded with a set of coefficients defining the surface for which it is to perform the intersection test.
A further improvement is described in our UK Patent Application No. 2298111. In this, the image plane is subdivided into sub-regions or tiles such that tiles can be processed in turn. It is proposed to use a variable tile size and to project a bounding box around complex objects so that only those tiles falling within the bounding box require processing. This is done by firstly determining the distribution of objects on the visible screen in order for a suitable tile size to be selected. The surfaces which define the various objects are then stored in a list, known as the display list, thereby avoiding the need to store identical surfaces for each tile, since one object made of many surfaces could appear in a number of tiles. Object pointers which identify the objects in the display list are also stored. There is one object pointer list per tile. The tiles can then be rendered in turn using the ray casting technique described above until all objects within each tile are processed. This is a useful method because no effort needs to be made to render objects which are known not to be visible in a particular tile.
A further improvement on this is proposed in our International Patent Application No. PCT/GB99/03707, in which any tiles within the bounding box which are not required to display a particular object are discarded before rendering.
A block diagram of the type of processor used is shown in FIG. 1. This comprises a tile accelerator unit 2 which performs the tiling operations referred to above and supplies the tile information to a display list memory 4. This in turn supplies tile object data for processing to the image synthesis processor (ISP) 6 which performs the ray/surface intersection tests referred to above. This derives image data which comprises object identification and depth data. After this, the thus derived image data is supplied to a texturing and shading processor (TSP) 8 which applies texturing and shading data to surfaces which have been determined as visible and outputs image shading data to a frame store.
Most 3-D graphic systems use what is known as immediate mode rendering. This type of rendering avoids the needs to store a copy of the entire scene in the display list memory. Instead, each polygon is rendered the moment that it is presented to the rendering hardware. This has the advantage of avoiding the storage requirements of the display list memory. However, it also precludes the considerable optimisation which are possible with the type of rendering described in our British Patent No. 2281682 and improved on in our British Patent Application No. 2298111. Advantages such as deferred texturing and translucency sorting are possible using this type of architecture.
The complexity of scenes which it is necessary to render using 3-D graphic systems is increasing as hardware becomes more powerful. However, this presents a problem for display list based renderers because the display list storage requirements also increase. In the past, if the display list memory became exhausted, parts of the scene would simply not be rendered. Image corruption of this sort is no longer considered acceptable. The cost of memory, which is not falling as fast as scene complexity is rising, makes increasing the amount of memory in the system unfeasible.